package serial

import (
	"encoding/json"
	"fmt"
)

// CommandType 命令类型
type CommandType string

const (
	CommandTypeBLE    CommandType = "ble"    // 蓝牙相关命令
	CommandTypeGPIO   CommandType = "gpio"   // GPIO控制命令
	CommandTypePWM    CommandType = "pwm"    // PWM控制命令
	CommandTypeADC    CommandType = "adc"    // ADC读取命令
	CommandTypeTemp   CommandType = "temp"   // 温度读取命令
	CommandTypeLED    CommandType = "led"    // LED控制命令
	CommandTypeSystem CommandType = "system" // 系统命令
)

// ActionType 动作类型
type ActionType string

const (
	ActionTypeSet    ActionType = "set"   // 设置操作
	ActionTypeGet    ActionType = "get"   // 获取操作
	ActionTypeConfig ActionType = "cfg"   // 配置操作
	ActionTypeBatch  ActionType = "batch" // 批量操作
)

// EventType 事件类型
type EventType string

const (
	EventTypeAdcKeyEvent    EventType = "adc_key_event"    // ADC按键事件
	EventTypeBLEScanResults EventType = "ble_scan_results" // BLE扫描结果
	EventTypeSystemStatus   EventType = "system_status"    // 系统状态
	EventTypeError          EventType = "error"            // 错误事件
)

// Command 命令结构
type Command struct {
	C CommandType            `json:"c"` // 命令类型
	A ActionType             `json:"a"` // 动作类型
	P map[string]interface{} `json:"p"` // 参数
}

// Response 响应结构
type Response struct {
	S string                 `json:"s"` // 状态: "succ" 或 "err"
	D map[string]interface{} `json:"d"` // 数据
}

// Event 事件结构（下位机主动上报）
type Event struct {
	Type EventType              `json:"type"` // 事件类型
	Data map[string]interface{} `json:"data"` // 事件数据
}

// KeyEvent 按键事件数据
type KeyEvent struct {
	Event     string `json:"event"`     // 事件类型：short_press, long_press, release
	Key       string `json:"key"`       // 按键名称：F1, F2, F3, F4等
	Timestamp int64  `json:"timestamp"` // 时间戳
}

// BLEScanDevice BLE扫描到的设备
type BLEScanDevice struct {
	MAC  string `json:"mac"`            // MAC地址
	Name string `json:"name"`           // 设备名称
	RSSI int    `json:"rssi,omitempty"` // 信号强度
}

// BLEScanResults BLE扫描结果数据
type BLEScanResults struct {
	Timestamp int64           `json:"timestamp"` // 时间戳
	Devices   []BLEScanDevice `json:"devices"`   // 扫描到的设备列表
}

// CreateCommand 创建命令
func CreateCommand(cmdType CommandType, actionType ActionType, params map[string]interface{}) *Command {
	return &Command{
		C: cmdType,
		A: actionType,
		P: params,
	}
}

// CreateBLESetCommand 创建BLE设置命令
func CreateBLESetCommand(enable bool, filterName string) *Command {
	params := map[string]interface{}{
		"enable": 0,
	}
	if enable {
		params["enable"] = 1
		if filterName != "" {
			params["filter_name"] = filterName
		}
	}

	return CreateCommand(CommandTypeBLE, ActionTypeSet, params)
}

// CreateGPIOSetCommand 创建GPIO设置命令
func CreateGPIOSetCommand(pin int, value int, mode string) *Command {
	params := map[string]interface{}{
		"pin":   pin,
		"value": value,
		"mode":  mode,
	}

	return CreateCommand(CommandTypeGPIO, ActionTypeSet, params)
}

// CreatePWMSetCommand 创建PWM设置命令
func CreatePWMSetCommand(channel int, duty int, freq int, enable bool) *Command {
	params := map[string]interface{}{
		"ch":   channel,
		"duty": duty,
		"freq": freq,
		"en": func() int {
			if enable {
				return 1
			}
			return 0
		}(),
	}

	return CreateCommand(CommandTypePWM, ActionTypeSet, params)
}

// CreateLEDSetCommand 创建LED设置命令
/*"text": "显示文字(最多4字符)",
  "dots": "小数点位掩码(0-15)",
  "brightness": "亮度等级(0-7)",
  "enable": "显示开关(0-1)"
*/
func CreateLEDSetCommand(text string, dots int, brightness int, enable bool) *Command {
	params := map[string]interface{}{
		"text":       text,
		"dots":       dots,
		"brightness": brightness,
		"enable": func() int {
			if enable {
				return 1
			}
			return 0
		}(),
	}

	return CreateCommand(CommandTypeLED, ActionTypeSet, params)
}

/*
CreateTempGetCommand 创建温度获取命令

	{
	  "c": "temp",     // 命令类型：温度传感器
	  "a": "get",      // 动作类型：get/set/cfg
	  "p": {}          // 参数对象
	}
*/
func CreateTempGetCommand() *Command {
	params := map[string]interface{}{}

	return CreateCommand(CommandTypeTemp, ActionTypeGet, params)
}

// ToJSON 将命令转换为JSON字符串
func (c *Command) ToJSON() (string, error) {
	data, err := json.Marshal(c)
	if err != nil {
		return "", fmt.Errorf("命令序列化失败: %w", err)
	}
	return string(data), nil
}

// ParseResponse 解析响应字符串
func ParseResponse(data string) (*Response, error) {
	var resp Response
	if err := json.Unmarshal([]byte(data), &resp); err != nil {
		return nil, fmt.Errorf("响应解析失败: %w", err)
	}
	return &resp, nil
}

// ParseEvent 解析事件字符串
func ParseEvent(data string) (*Event, error) {
	var event Event
	if err := json.Unmarshal([]byte(data), &event); err != nil {
		return nil, fmt.Errorf("事件解析失败: %w", err)
	}
	return &event, nil
}

// IsSuccess 检查响应是否成功
func (r *Response) IsSuccess() bool {
	return r.S == "succ"
}

// GetErrorMessage 获取错误消息
func (r *Response) GetErrorMessage() string {
	if r.IsSuccess() {
		return ""
	}

	if errMsg, ok := r.D["error"].(string); ok {
		return errMsg
	}

	return "未知错误"
}

// ParseKeyEvent 解析按键事件
func (e *Event) ParseKeyEvent() (*KeyEvent, error) {
	if e.Type != EventTypeAdcKeyEvent {
		return nil, fmt.Errorf("事件类型不匹配，期望 %s，实际 %s", EventTypeAdcKeyEvent, e.Type)
	}

	data, err := json.Marshal(e.Data)
	if err != nil {
		return nil, fmt.Errorf("事件数据序列化失败: %w", err)
	}

	var keyEvent KeyEvent
	if err := json.Unmarshal(data, &keyEvent); err != nil {
		return nil, fmt.Errorf("按键事件解析失败: %w", err)
	}

	return &keyEvent, nil
}

// ParseBLEScanResults 解析BLE扫描结果
func (e *Event) ParseBLEScanResults() (*BLEScanResults, error) {
	if e.Type != EventTypeBLEScanResults {
		return nil, fmt.Errorf("事件类型不匹配，期望 %s，实际 %s", EventTypeBLEScanResults, e.Type)
	}

	data, err := json.Marshal(e.Data)
	if err != nil {
		return nil, fmt.Errorf("事件数据序列化失败: %w", err)
	}

	var scanResults BLEScanResults
	if err := json.Unmarshal(data, &scanResults); err != nil {
		return nil, fmt.Errorf("BLE扫描结果解析失败: %w", err)
	}

	return &scanResults, nil
}
